package utils;

import java.io.*;

public class ReadWriteTextFile
{

	/**
	 * Fetch the entire contents of a text file, and return it in a String. This
	 * style of implementation does not throw Exceptions to the caller.
	 * 
	 * @param aFile
	 *            is a file which already exists and can be read.
	 */
	static public String getContents(File aFile)
	{
		// ...checks on aFile are elided
		StringBuilder contents = new StringBuilder();

		try
		{
			// use buffering, reading one line at a time
			// FileReader always assumes default encoding is OK!
			BufferedReader input = new BufferedReader(new FileReader(aFile));
			try
			{
				String line = null; // not declared within while loop
				/*
				 * readLine is a bit quirky : it returns the content of a line
				 * MINUS the newline. it returns null only for the END of the
				 * stream. it returns an empty String if two newlines appear in
				 * a row.
				 */
				while ((line = input.readLine()) != null)
				{
					contents.append(line);
					contents.append(System.getProperty("line.separator"));
				}
			}
			finally
			{
				input.close();
			}
		}
		catch (IOException ex)
		{
			ex.printStackTrace();
		}

		return contents.toString();
	}

	/**
	 * Change the contents of text file in its entirety, overwriting any
	 * existing text.
	 * 
	 * This style of implementation throws all exceptions to the caller.
	 * 
	 * @param aFile
	 *            is an existing file which can be written to.
	 * @throws IllegalArgumentException
	 *             if param does not comply.
	 * @throws FileNotFoundException
	 *             if the file does not exist.
	 * @throws IOException
	 *             if problem encountered during write.
	 */
	static public void setContents(File aFile, String aContents)
			throws FileNotFoundException, IOException
	{
		if (aFile == null)
		{
			throw new IllegalArgumentException("File should not be null.");
		}
		if (!aFile.exists())
		{
			Writer output = new BufferedWriter(new FileWriter(aFile, true));
			output.write("");
			output.close();
			// throw new FileNotFoundException("File does not exist: " + aFile);
		}
		if (!aFile.isFile())
		{
			throw new IllegalArgumentException("Should not be a directory: "
					+ aFile);
		}
		if (!aFile.canWrite())
		{
			throw new IllegalArgumentException("File cannot be written: "
					+ aFile);
		}

		// use buffering
		Writer output = new BufferedWriter(new FileWriter(aFile, true));
		try
		{
			// FileWriter always assumes default encoding is OK!
			output.append(aContents);
			output.append(System.getProperty("line.separator"));
		} 
		finally
		{
			output.close();
		}
	}

	/** Simple test harness. */
	public static void main(String... aArguments) throws IOException
	{
		File testFile = new File("blah.txt");
		System.out.println("Original file contents: " + getContents(testFile));
		setContents(testFile,
				"The content of this file has been overwritten...");
		System.out.println("New file contents: " + getContents(testFile));
	}
}